//public class Variable {
//    public static void main(String[] args) {
//        System.out.println("Variable");
//    }
//
//
//    /**
//     * 基本类型变量
//     */
//    void BasicType() {
//        /**
//         * 整型：整型变量用于存放整数。
//         *      byte: 长度8位，数的范围（-128 ~ 127）;
//         *      short: 长度16位，数的范围（-2^15 ~ 2^15 - 1 ）;
//         *      int: 长度32位，数的范围（-2^31 ~ 2^31 - 1）;
//         *      long: 长度64位，数的范围（-2^63 ~ 2^63 - 1）;
//         */
//        byte b = 1;
//        short s = 200;
//        int i = 300;
//        long l = 400;
//
//        /**
//         * 浮点型：
//         *      float: 长度32位，数的范围（3.4E-038 ~ 3.4E+038）;
//         *      double: 长度64位，数的范围（1.7E-308 ~ 1.7E+308）;
//         * 注意：默认的小数值是double类型的。
//         *      需在数字后面加一个字母f，直接把该数字声明成float类型。
//         */
////        float f = 54.321; //该行会出现编译错误，因为54.321是double型的
//        float f2 = 54.321f;
//        double d = 123.45;
//
//        /**
//         * 字符型：char类型用于存放一个字符，值用单引号'表示 (双引号表示string字符串)。
//         */
//        char c = '中'; // char 只能存放一个字符，超过一个字符就会产生编译错误
//        String str = "Hello Java";
//
//
//        /**
//         * 布尔型：用于表示真假。
//         *      boolean: 长度1位，数的范围（false、true），默认false;
//         * 注意：虽然布尔型真正存放的数据是0(false) 1(true)，
//         *      但是，不能直接使用0 1 进行赋值。
//         */
//        boolean b1 = true;
//        boolean b2 = false;
//    }
//
//    void Test_1() {
//        float pi = 3.14f;
//        double d = 2.769343;
//        int year = 365;
//        byte b = 12;
//        char single = '吃';
//        boolean bool = false;
//        String desc = "不可描述";
//    }
//
//
//    /**
//     * 字面量： 给基本类型的变量赋值的方式叫做 字面值。
//     */
//    void Literally() {
//        /**
//         * 整数 字面值
//         *      byte, short, int 和 long 的值都可以通过 int 类型的字面值来创建。
//         * 整数的字面值可以用如下四种进制来表示：
//         *      十进制: 基 10, 包含从0-9的数字，平常用的就是这种
//         *      十六进制: 基 16, 包含从0-9的数字，和从A-F的字母。
//         *      八进制: 基 8, 包含从0-7的数字
//         *      二进制: 基 2, 包含0和1。（从 JAVA7开始就可以创建 二进制的字面值了）
//         */
//        long val = 26L; // 以L结尾的字面值表示long型
//        int decVal = 26; // 默认就是int型， 10进制
//        int hexVal = 0x1a; // 16进制
//        int oxVal = 032; // 8进制
//        int binVal = 0b11010; // 2进制
//
//
//        /**
//         * 浮点数 字面值
//         *      浮点数还可以用E或者e表示（科学计数法）
//         *      e2表示10的二次方，即100
//         */
//        float f1 = 123.4F; // 以F结尾的字面值表示float类型
//        double d1 = 123.4; // 默认就是double类型
//        double d2 = 1.234e2; // 科学计数法表示double
//
//
//        /**
//         * 字符和字符串 字面值
//         *      字符的字面值放在单引号中；
//         *      字符串的字面值放在双引号中；
//         *      需要注意的是， \ 表示转义。
//         */
//        String name = "盖伦";
//        char a= 'c';
//
//        //以下是转义字符
//        char tab = '\t';            // 制表符
//        char carriageReturn = '\r'; // 回车
//        char newLine = '\n';        // 换行
//        char doubleQuote = '\"';    // 双引号
//        char singleQuote = '\'';    // 单引号
//        char backslash = '\\';      // 反斜杠
//    }
//
//    void Test_2() {
//        byte b = 127;
//        short s = 225;
//        int i = 10000;
//        long l = 123456L;
//        float f = 3.1315F;
//        double d = 3.14;
//        char c = 'x';
//        String str = "HelloWorld";
//    }
//
//
//    /**
//     * 类型转换
//     */
//    void TypeConversion() {
//        /**
//         * 转换规则： 由小到大自动转， 从大到小强制转；
//         *      精度高的数据类型就像容量大的杯子，可以放更大的数据
//         *      精度低的数据类型就像容量小的杯子，只能放更小的数据
//         *      小杯子往大杯子里倒东西，大杯子怎么都放得下
//         *      大杯子往小杯子里倒东西，有的时候放的下，有的时候就会有溢出
//         */
//        char c = 'A';
//        short s = 80;
//
//        // 虽然 short 和 char 都是16位的，长度是一样的
//        // 但是彼此之间，依然需要进行强制转换
//        c = (char) s;
//        // 直接进行转换，会出现编译错误
//        c = s;
//        s = c;
//
//
//        /**
//         * 低精度向高精度转换
//         */
//        long l = 50;
//        int i = 50;
//
//        // 低精度向高精度转换 是可以正常转换的
//        // int比较小，要放进比较大的long,随便怎么样，都放的进去
//        l = i;
//
//
//        /**
//         * 高精度向低精度转换
//         */
//        byte b = 5;
//        int i1 = 10;
//        int i2 = 300;
//
//        b = (byte) i1;
//        // 因为i1的值是在byte范围之内，所以即便进行强制转换， 最后得到的值，也是10
//        System.out.println(b);
//
//        // 因为i2的值是在byte范围之外，所以就会按照byte的长度进行截取
//        // i2的值是300，其对应的二进制数是 100101100
//        // 按照byte的长度8位进行截取后，其值为 00101100 即44
//        b =(byte) i2;
//        System.out.println(b);
//
//        // 查看一个整数对应的二进制的方法：
//        System.out.println(Integer.toBinaryString(i2));
//    }
//
//    void Test_3() {
//        short a = 1;
//        short b = 2;
//        // 那么 a+b 是什么类型？
//        // 答： int 类型
//
//        /**
//         * Java中进行二元与运算类型的提升规则
//         *
//         *      整数运算：
//         *      如果两个操作数有一个为long，则结果也为long；
//         *      没有long时，结果为int。即使操作数全为short、byte，结果也是int。
//         *
//         *      浮点运算：
//         *      如果两个操作数有一个为double，则结果为double；
//         *      只有两个操作数都是float，则结果才为float。
//         *
//         *      注意：int 与 float 运算，结果为 float。
//         */
//    }
//
//
//    /**
//     * 命名规则
//     */
//    void NamingConventions() {
//        /**
//         * 变量命名只能使用字母 数字 $ _
//         * 变量第一个字符 只能使用 字母 $ _
//         * 变量第一个字符 不能使用数字
//         * 注：_ 是下划线，不是-减号或者—— 破折号
//         */
//        int a= 5;
//        int a_12= 5;
//        int $a43= 5;
//        int a434= 5;
//
//        //第一个是数字，是不行的
//        int 34a= 5;
//
//
//        /**
//         * 在命名的时候，尽量使用完整的单词进行命名，比如name,moveSpeed，而不是使用缩写 n,m。
//         * 不能只使用关键字，但是可以包含关键字。
//         */
//        String name;
//        float hp;
//        int moveSpeed;
//
//        int class5 = 5;
//
//
//        /**
//         * 关键字列表
//         */
//        // 异常处理 try | carch | finally | throw | throws
//        // 对象相关 new | extends | implements | class | instanceof | this | super
//        // 字面值常量 false | true | null
//        // 方法相关 return | void
//        // 包相关 package | import
//        // 未使用的 const | goto
//
//        // 基本数据类型 byte | short | int | long | float | double | char | boolean
//        // 循环关键字 do | while | for | break | continue
//        // 分支关键字 if | else | switch | case | default
//        // 方法、变量和类修饰符 private | public | protected | final | static | abstract | synchronized | transient | volatile | strictfp
//
//
//        /**
//         * 中文也是可以用来命名变量的
//         */
//        class 苍老师 {
//            public void 开展教学工作(){
//                System.out.println("雅蠛蝶");
//            }
//
//            public void entry(String[] args) {
//                苍老师 苍 = new 苍老师();
//                苍.开展教学工作();
//            }
//        }
//    }
//
//    void Test_4() {
//        // 思考如下变量命名是否合法，如果不合法，为什么？
//        int a_;
//        int a@;
//        int a3;
//        int 8@;
//        int 9_;
//        int X$_;
//        int y;
//        int _$_;
//        int $_$;
//        int $*$;
//        int $1$;
//        int _1_;
//        int _@_;
//        int a#;
//        int a";
//        int 123a";
//        int 123a_;
//        int $123b_;
//    }
//
//
//    /**
//     * 作用域
//     */
//    void Scope() {
//        /**
//         * 字段，属性，Field
//         *      当一个变量被声明在类下面
//         *      变量就叫做 字段或者属性、成员变量、Field
//         */
//        class HelloWorld1 {
//            // 比如变量i,就是一个属性。
//            // 那么从第2行这个变量声明的位置开始，整个类都可以访问得到
//            // 所以其作用域就是从其声明的位置开始的整个类
//            int i = 1;
//            int j = i;  //其他的属性可以访问i
//            public void method1(){
//                System.out.println(i); //方法1里可以访问i
//            }
//            public void method2(){
//                System.out.println(i); //方法2里可以访问i
//            }
//        }
//
//
//        /**
//         * 参数：如果一个变量，是声明在一个方法上的，就叫做参数
//         *      参数的作用域即为该方法内的所有代码
//         *          其他方法不能访问该参数
//         *          类里面也不能访问该参数
//         */
//        class HelloWorld2 {
//            public void method1(int i){ //参数i的作用域即方法method1
//                System.out.println(i);
//            }
//            public void method2(){
//                System.out.println(i); //method2 不能访问参数i
//            }
//            int j = i;  //类里面也不能访问参数i
//        }
//
//
//        /**
//         * 局部变量：声明在方法内的变量，叫做局部变量
//         *      其作用域在声明开始的位置，到其所处于的块结束位置
//         */
//        class HelloWorld3 {
//            public void method1() {
//                int i  = 5;  //其作用范围是从声明的第4行，到其所处于的块结束12行位置
//                System.out.println(i);
//                {   // 子块
//                    System.out.println(i); //可以访问i
//                    int j = 6;
//                    System.out.println(j); //可以访问j
//                }
//                System.out.println(j); //不能访问j,因为其作用域到第10行就结束了
//            }
//        }
//    }
//
//    void Test_5() {
//        // 属性的作用域在方法中，参数的作用域也在方法中，如果属性和参数命名相同了的话？ 那么到底取哪个值？
//        class HelloWorld {
//            int i = 1; //属性名是i
//            public void method1(int i){ //参数也是i
//                System.out.println(i);
//            }
//
//            public static void main(String[] args) {
//                new HelloWorld().method1(5);
//                //结果打印出来是 1还是5?     // 5
//            }
//        }
//    }
//
//
//    /**
//     * Final：修饰一个变量，有很多种说法，比如不能改变等等
//     *      准确的描述是 当一个变量被final修饰的时候，该变量只有一次赋值的机会
//     */
//    void Final() {
//        /**
//         * 在声明的时候赋值
//         */
//        final int i = 5;
//        i = 10; // i 在上面已经被赋值过了，所以这里会出现编译错误
//
//
//        /**
//         * 在声明的时候没有赋值
//         */
//        final int i;
//        i = 10; // i 在上面，只是被声明，但是没有被赋值，所以在这里可以进行第一次赋值
//        i = 11; // i 在上面已经被赋值过了，所以这里会出现编译错误
//
//
//        /**
//         * final 修饰其他
//         */
//        // final 除了修饰变量，还可以修饰类，修饰方法
//    }
//
//    void Test_6() {
//        // 如果final修饰的是参数，能否在方法里给这个参数赋值？
//        void method1(final int j) {
//            j = 5; //这个能否执行？
//        }
//    }
//
//
//    /**
//     * 表达式
//     */
//    void Expression() {
//        /**
//         * 以 ; 结尾的一段代码，即为一个表达式
//         */
//        // 表达式是由变量、操作符以及方法调用所构成的结构。
//        //每一句话都是一个表达式
//        int i = 5;
//        System.out.println(5);
//
//
//        /**
//         *  ; 也是一个完整的表达式
//         */
//        //一个空;也是一个表达式
//        ;
//        ;
//    }
//
//    void Test_7() {}
//
//
//    /**
//     * Block
//     */
//    void Block() {
//        /**
//         *  从 { 开始， 到对应的 } 结束，即一个块
//         */
//        public class HelloWorld { //类对应的块
//            public static void main(String[] args) { //主方法对应的块
//                System.out.println("abc");
//            }
//        }
//    }
//
//    void Test_8() {}
//}